using System.Globalization;
using System.Net;
using System.Runtime.CompilerServices;
using System.Text.RegularExpressions;

namespace Sage.Data.Validation
{
    /// <summary>
    /// 提供格式验证的扩展方法。
    /// </summary>
    /// <remarks>
    /// 此类包含各种常见的格式验证方法，如邮箱、手机号、URL、身份证号码等。
    /// 使用 <see cref="GeneratedRegexAttribute"/> 属性以支持 AOT 编译优化。
    /// </remarks>
    public static partial class ValidationExtensions
    {

        #region 基础验证

        /// <summary>
        /// 验证字符串是否是有效的数字格式（整数或小数）。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的数字，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// "123".IsNumeric()     // true
        /// "123.45".IsNumeric()  // true  
        /// "-123".IsNumeric()    // true
        /// "1.23E+5".IsNumeric() // true
        /// "1,234".IsNumeric()   // true
        /// "abc".IsNumeric()     // false
        /// "".IsNumeric()        // false
        /// </code>
        /// </example>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsNumeric(this string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            return double.TryParse(value, NumberStyles.Any, CultureInfo.InvariantCulture, out _);
        }

        /// <summary>
        /// 验证字符串是否只包含数字字符（0-9）。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>是否只包含数字字符。</returns>
        /// <example>
        /// <code>
        /// "123".IsDigitsOnly()     // true
        /// "123.45".IsDigitsOnly()  // false
        /// "-123".IsDigitsOnly()    // false  
        /// "abc123".IsDigitsOnly()  // false
        /// </code>
        /// </example>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsDigitsOnly(this string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            return value!.All(char.IsDigit);
        }

        /// <summary>
        /// 验证字符串是否为有效的整数格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>是否为有效的整数格式。</returns>
        /// <example>
        /// <code>
        /// "123".IsInteger()     // true
        /// "-123".IsInteger()    // true
        /// "123.45".IsInteger()  // false
        /// </code>
        /// </example>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsInteger(this string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            return long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out _);
        }

        /// <summary>
        /// 验证字符串是否为有效的小数格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>是否为有效的小数格式。</returns>
        /// <example>
        /// <code>
        /// "123.45".IsDecimal()  // true
        /// "-123.45".IsDecimal() // true
        /// "123".IsDecimal()     // true (整数也是有效小数)
        /// "abc".IsDecimal()     // false
        /// </code>
        /// </example>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsDecimal(this string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            return decimal.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out _);
        }

        /// <summary>
        /// 验证字符串是否是有效的日期格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串可以被解析为日期，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// "2024-01-15".IsValidDate()        // true
        /// "2024/01/15".IsValidDate()        // true
        /// "01-15-2024".IsValidDate()        // true
        /// "2024-01-15 14:30:25".IsValidDate() // true
        /// "invalid date".IsValidDate()      // false
        /// </code>
        /// </example>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsValidDate(this string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            return DateTime.TryParse(value, out _);
        }

        /// <summary>
        /// 使用指定的正则表达式验证字符串格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <param name="pattern">要匹配的正则表达式模式。</param>
        /// <returns>如果字符串符合正则表达式模式，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// "abc123".MatchesPattern(@"^[a-z]+\d+$")  // true
        /// "123abc".MatchesPattern(@"^\d+[a-z]+$")  // true
        /// "ABC123".MatchesPattern(@"^[a-z]+\d+$")  // false
        /// </code>
        /// </example>
        /// <exception cref="ArgumentNullException">正则表达式模式 <paramref name="pattern"/> 为空时抛出。</exception>
        /// <exception cref="ArgumentException">正则表达式无效时抛出。</exception>
        public static bool MatchesPattern(this string? value, string pattern)
        {
            ArgumentNullException.ThrowIfNull(pattern);

            if (string.IsNullOrWhiteSpace(value))
                return false;

            try
            {
                return Regex.IsMatch(value!, pattern);
            }
            catch (ArgumentException ex)
            {
                throw new ArgumentException("无效的正则表达式模式。", nameof(pattern), ex);
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 验证字符串是否只包含字母。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>是否只包含字母。</returns>
        /// <example>
        /// <code>
        /// "abc".IsAlpha()      // true
        /// "ABC".IsAlpha()      // true
        /// "aBc".IsAlpha()      // true
        /// "abc123".IsAlpha()   // false
        /// "abc-def".IsAlpha()  // false
        /// </code>
        /// </example>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsAlpha(this string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            return value!.All(char.IsLetter);
        }

        /// <summary>
        /// 验证字符串是否只包含字母和数字。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>是否只包含字母和数字。</returns>
        /// <example>
        /// <code>
        /// "abc123".IsAlphaNumeric()    // true
        /// "ABC123".IsAlphaNumeric()    // true
        /// "aBc123".IsAlphaNumeric()    // true
        /// "abc-123".IsAlphaNumeric()   // false
        /// "abc 123".IsAlphaNumeric()   // false
        /// </code>
        /// </example>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool IsAlphaNumeric(this string? value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            return value!.All(char.IsLetterOrDigit);
        }

        #endregion

        #region 联系方式验证

        /// <summary>
        /// 验证字符串是否是有效的电子邮箱地址格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的邮箱地址格式，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string email = "user@example.com";
        /// bool isValid = email.IsValidEmail(); // 返回 true
        /// 
        /// string invalidEmail = "invalid.email";
        /// bool isInvalid = invalidEmail.IsValidEmail(); // 返回 false
        /// </code>
        /// </example>
        public static bool IsValidEmail(this string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            try
            {
                return EmailRegex().IsMatch(value);
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 获取用于验证邮箱格式的正则表达式。
        /// </summary>
        /// <returns>用于邮箱格式验证的 <see cref="Regex"/> 实例。</returns>
        /// <remarks>
        /// 匹配常见的 email 格式，不保证所有邮箱地址的 RFC 合规性。
        /// </remarks>
        [GeneratedRegex(@"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")]
        private static partial Regex EmailRegex();

        /// <summary>
        /// 验证字符串是否是有效的中国大陆手机号码格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的中国大陆手机号码，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string phone = "13812345678";
        /// bool isValid = phone.IsValidChinesePhoneNumber(); // 返回 true
        /// 
        /// string invalidPhone = "12345678901";
        /// bool isInvalid = invalidPhone.IsValidChinesePhoneNumber(); // 返回 false
        /// </code>
        /// </example>
        public static bool IsValidChinesePhoneNumber(this string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            try
            {
                return ChinesePhoneNumberRegex().IsMatch(value);
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 获取用于验证中国大陆手机号码格式的正则表达式。
        /// </summary>
        /// <returns>用于手机号码格式验证的 <see cref="Regex"/> 实例。</returns>
        /// <remarks>
        /// 匹配以 1 开头的 11 位中国大陆手机号（13~19 段）。
        /// </remarks>
        [GeneratedRegex(@"^1[3-9]\d{9}$")]
        private static partial Regex ChinesePhoneNumberRegex();

        #endregion

        #region 网络相关验证

        /// <summary>
        /// 验证字符串是否是有效的 URL 格式（仅支持 http/https）。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的 URL，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string url = "https://www.example.com";
        /// bool isValid = url.IsValidUrl(); // 返回 true
        /// 
        /// string invalidUrl = "not-a-url";
        /// bool isInvalid = invalidUrl.IsValidUrl(); // 返回 false
        /// </code>
        /// </example>
        public static bool IsValidUrl(this string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            try
            {
                if (Uri.TryCreate(value, UriKind.Absolute, out Uri? uriResult))
                {
                    return uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps;
                }
                return false;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 验证字符串是否是有效的 IP 地址（IPv4 或 IPv6）格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的 IP 地址，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string ipv4 = "192.168.1.1";
        /// bool isValid = ipv4.IsValidIpAddress(); // 返回 true
        /// 
        /// string ipv6 = "2001:db8::1";
        /// bool isValidIpv6 = ipv6.IsValidIpAddress(); // 返回 true
        /// </code>
        /// </example>
        public static bool IsValidIpAddress(this string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            return IPAddress.TryParse(value, out _);
        }

        /// <summary>
        /// 智能判断字符串是否为有效IP地址（IPv4、IPv6）或IP+端口（IPv4:port、[IPv6]:port）。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的 IP 地址或 IP+端口 格式，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string ipv4WithPort = "192.168.1.1:8080";
        /// bool isValid = ipv4WithPort.IsSmartValidIpAddress(); // 返回 true
        /// 
        /// string ipv6WithPort = "[2001:db8::1]:8080";
        /// bool isValidIpv6 = ipv6WithPort.IsSmartValidIpAddress(); // 返回 true
        /// 
        /// string simpleIp = "127.0.0.1";
        /// bool isValidIp = simpleIp.IsSmartValidIpAddress(); // 返回 true
        /// </code>
        /// </example>
        public static bool IsSmartValidIpAddress(this string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            // 检查 IPv6 + 端口: [2001:db8::1]:8080
            var match = Ipv6WithPortRegex().Match(value);
            if (match.Success)
            {
                var ip = match.Groups[1].Value;
                var portStr = match.Groups[2].Value;
                if (IPAddress.TryParse(ip, out var ipAddress) &&
                    ipAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6 &&
                    int.TryParse(portStr, out int port) &&
                    port > 0 && port <= 65535)
                {
                    return true;
                }
                return false;
            }

            // 检查 IPv4 + 端口: 192.168.1.1:8080
            match = Ipv4WithPortRegex().Match(value);
            if (match.Success)
            {
                var ip = match.Groups[1].Value;
                var portStr = match.Groups[2].Value;
                if (IPAddress.TryParse(ip, out var ipAddress) &&
                    ipAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork &&
                    int.TryParse(portStr, out int port) &&
                    port > 0 && port <= 65535)
                {
                    return true;
                }
                return false;
            }

            // 没有端口分隔符，直接按IP校验
            return IPAddress.TryParse(value, out _);
        }

        [GeneratedRegex(@"^\[(.+)\]:(\d{1,5})$")]
        private static partial Regex Ipv6WithPortRegex();

        [GeneratedRegex(@"^([0-9.]+):(\d{1,5})$")]
        private static partial Regex Ipv4WithPortRegex();

        /// <summary>
        /// 验证字符串是否是有效的 IPv4 地址格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的 IPv4 地址，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string ipv4 = "192.168.1.1";
        /// bool isValid = ipv4.IsValidIpv4Address(); // 返回 true
        /// 
        /// string ipv6 = "2001:db8::1";
        /// bool isNotIpv4 = ipv6.IsValidIpv4Address(); // 返回 false
        /// </code>
        /// </example>
        public static bool IsValidIpv4Address(this string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            if (IPAddress.TryParse(value, out IPAddress? ip))
            {
                return ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork;
            }
            return false;
        }

        /// <summary>
        /// 验证字符串是否是有效的 IPv6 地址格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的 IPv6 地址，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string ipv6 = "2001:db8::1";
        /// bool isValid = ipv6.IsValidIpv6Address(); // 返回 true
        /// 
        /// string ipv4 = "192.168.1.1";
        /// bool isNotIpv6 = ipv4.IsValidIpv6Address(); // 返回 false
        /// </code>
        /// </example>
        public static bool IsValidIpv6Address(this string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            if (IPAddress.TryParse(value, out IPAddress? ip))
            {
                return ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6;
            }
            return false;
        }

        /// <summary>
        /// 验证 IPv4 地址是否是私有地址。
        /// </summary>
        /// <param name="value">要验证的 IPv4 地址字符串。</param>
        /// <returns>如果是私有 IP 地址，则返回 true；否则返回 false。</returns>
        /// <remarks>
        /// 私有 IP 地址范围包括：
        /// - 10.0.0.0 - 10.255.255.255 (10/8 前缀)
        /// - 172.16.0.0 - 172.31.255.255 (172.16/12 前缀)
        /// - 192.168.0.0 - 192.168.255.255 (192.168/16 前缀)
        /// </remarks>
        /// <example>
        /// <code>
        /// string privateIp = "192.168.1.1";
        /// bool isPrivate = privateIp.IsPrivateIpv4Address(); // 返回 true
        /// 
        /// string publicIp = "8.8.8.8";
        /// bool isNotPrivate = publicIp.IsPrivateIpv4Address(); // 返回 false
        /// </code>
        /// </example>
        public static bool IsPrivateIpv4Address(this string value)
        {
            if (!value.IsValidIpv4Address())
                return false;

            IPAddress ip = IPAddress.Parse(value);
            byte[] bytes = ip.GetAddressBytes();

            // 10.0.0.0/8
            if (bytes[0] == 10)
                return true;

            // 172.16.0.0/12
            if (bytes[0] == 172 && bytes[1] >= 16 && bytes[1] <= 31)
                return true;

            // 192.168.0.0/16
            if (bytes[0] == 192 && bytes[1] == 168)
                return true;

            return false;
        }

        /// <summary>
        /// 验证 IP 地址是否是回环地址。
        /// </summary>
        /// <param name="value">要验证的 IP 地址字符串。</param>
        /// <returns>如果是回环地址，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string loopback = "127.0.0.1";
        /// bool isLoopback = loopback.IsLoopbackIpAddress(); // 返回 true
        /// 
        /// string ipv6Loopback = "::1";
        /// bool isIpv6Loopback = ipv6Loopback.IsLoopbackIpAddress(); // 返回 true
        /// 
        /// string normalIp = "192.168.1.1";
        /// bool isNotLoopback = normalIp.IsLoopbackIpAddress(); // 返回 false
        /// </code>
        /// </example>
        public static bool IsLoopbackIpAddress(this string value)
        {
            if (!value.IsValidIpAddress())
                return false;

            IPAddress ip = IPAddress.Parse(value);
            return IPAddress.IsLoopback(ip);
        }

        #endregion

        #region 中国特定格式验证

        /// <summary>
        /// 验证字符串是否是有效的中国身份证号码格式（18位标准）。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的中国身份证号码，则返回 true；否则返回 false。</returns>
        /// <remarks>
        /// 该方法会校验身份证号码的长度、格式及校验码。
        /// </remarks>
        /// <example>
        /// <code>
        /// string validIdCard = "11010519491231002X";
        /// bool isValid = validIdCard.IsValidChineseIdCard(); // 返回 true（如果校验码正确）
        /// 
        /// string invalidIdCard = "123456789012345678";
        /// bool isInvalid = invalidIdCard.IsValidChineseIdCard(); // 返回 false
        /// </code>
        /// </example>
        public static bool IsValidChineseIdCard(this string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            try
            {
                if (!ChineseIdCardRegex().IsMatch(value))
                    return false;

                // 校验最后一位
                if (value.Length == 18)
                {
                    // 加权因子
                    int[] weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
                    // 校验码对应值
                    char[] checkCodes = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];

                    int sum = 0;
                    for (int i = 0; i < 17; i++)
                    {
                        if (!char.IsDigit(value[i]))
                            return false;

                        sum += (value[i] - '0') * weights[i];
                    }

                    int mod = sum % 11;
                    char checkCode = checkCodes[mod];

                    return char.ToUpper(value[17]) == checkCode;
                }

                return false;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 获取用于验证中国身份证号码格式的正则表达式。
        /// </summary>
        /// <returns>用于身份证格式验证的 <see cref="Regex"/> 实例。</returns>
        /// <remarks>
        /// 只支持 18 位身份证号码。
        /// </remarks>
        [GeneratedRegex(@"^[1-9]\d{5}(19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dX]$")]
        private static partial Regex ChineseIdCardRegex();

        /// <summary>
        /// 验证字符串是否是有效的中国邮政编码格式。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <returns>如果字符串是有效的中国邮政编码，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string postalCode = "100000";
        /// bool isValid = postalCode.IsValidChinesePostalCode(); // 返回 true
        /// 
        /// string invalidCode = "000000";
        /// bool isInvalid = invalidCode.IsValidChinesePostalCode(); // 返回 false
        /// </code>
        /// </example>
        public static bool IsValidChinesePostalCode(this string value)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            try
            {
                return ChinesePostalCodeRegex().IsMatch(value);
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// 获取用于验证中国邮政编码格式的正则表达式。
        /// </summary>
        /// <returns>用于邮政编码格式验证的 <see cref="Regex"/> 实例。</returns>
        /// <remarks>
        /// 匹配中国大陆 6 位邮政编码，不以 0 开头。
        /// </remarks>
        [GeneratedRegex(@"^[1-9]\d{5}$")]
        private static partial Regex ChinesePostalCodeRegex();

        #endregion

        #region 安全相关验证

        /// <summary>
        /// 验证字符串是否符合指定的密码强度要求。
        /// </summary>
        /// <param name="value">要验证的字符串。</param>
        /// <param name="minLength">密码最小长度，默认为 8。</param>
        /// <param name="requireUppercase">是否要求至少包含一个大写字母，默认为 false。</param>
        /// <param name="requireLowercase">是否要求至少包含一个小写字母，默认为 false。</param>
        /// <param name="requireDigit">是否要求至少包含一个数字，默认为 false。</param>
        /// <param name="requireSpecialChar">是否要求至少包含一个特殊字符，默认为 false。</param>
        /// <returns>如果字符串符合密码强度要求，则返回 true；否则返回 false。</returns>
        /// <example>
        /// <code>
        /// string weakPassword = "123456";
        /// bool isWeak = weakPassword.IsStrongPassword(); // 返回 true（只检查长度）
        /// 
        /// string strongPassword = "MyP@ssw0rd";
        /// bool isStrong = strongPassword.IsStrongPassword(8, true, true, true, true); // 返回 true
        /// 
        /// string simplePassword = "password";
        /// bool needsDigits = simplePassword.IsStrongPassword(requireDigit: true); // 返回 false
        /// </code>
        /// </example>
        public static bool IsStrongPassword(this string value, int minLength = 8,
                                            bool requireUppercase = false,
                                            bool requireLowercase = false,
                                            bool requireDigit = false,
                                            bool requireSpecialChar = false)
        {
            if (string.IsNullOrWhiteSpace(value))
                return false;

            if (value.Length < minLength)
                return false;

            if (requireUppercase && !value.Any(char.IsUpper))
                return false;

            if (requireLowercase && !value.Any(char.IsLower))
                return false;

            if (requireDigit && !value.Any(char.IsDigit))
                return false;

            if (requireSpecialChar && !value.Any(c => !char.IsLetterOrDigit(c)))
                return false;

            return true;
        }

        #endregion

        #region 文件路径验证
        /// <summary>
        /// 判断路径是否为绝对路径。
        /// </summary>
        /// <param name="path">要检查的路径。</param>
        /// <returns>
        /// 如果是绝对路径则返回true，否则返回false。
        /// </returns>
        /// <example>
        /// <code>
        /// string absolutePath = @"C:\Users\Username\Documents\file.txt";
        /// bool isAbsolute = absolutePath.IsAbsolutePath(); // 返回 true
        /// 
        /// string unixAbsolutePath = "/home/user/file.txt";
        /// bool isUnixAbsolute = unixAbsolutePath.IsAbsolutePath(); // 返回 true
        /// 
        /// string relativePath = "docs/readme.txt";
        /// bool isRelative = relativePath.IsAbsolutePath(); // 返回 false
        /// 
        /// string currentDir = "./config.json";
        /// bool isCurrent = currentDir.IsAbsolutePath(); // 返回 false
        /// 
        /// string networkPath = @"\\server\share\file.txt";
        /// bool isNetwork = networkPath.IsAbsolutePath(); // 返回 true
        /// </code>
        /// </example>
        /// <remarks>
        /// 此方法内部使用Path.IsPathFullyQualified实现（.NET Core 2.1+）。
        /// 在Windows系统中，绝对路径以盘符开头（如C:\）或网络路径（\\server\share）。
        /// 在Unix系统中，绝对路径以根目录"/"开头。
        /// 适用于路径验证、路径处理逻辑判断等场景。
        /// </remarks>
        public static bool IsAbsolutePath(this string? path)
        {
            if (string.IsNullOrEmpty(path))
                return false;

            try
            {
                return Path.IsPathFullyQualified(path!);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 判断路径字符串是否包含无效字符。
        /// </summary>
        /// <param name="path">要检查的路径。</param>
        /// <remarks>
        /// 此方法检查路径中是否包含Path.GetInvalidPathChars()返回的无效字符。
        /// 无效字符在不同操作系统中可能不同，该方法会根据当前运行环境进行检查。
        /// 适用于文件路径验证、用户输入校验等场景。
        /// </remarks>
        public static bool HasInvalidPathChars(this string? path)
        {
            if (string.IsNullOrEmpty(path))
                return false;

            try
            {
                return path!.IndexOfAny(Path.GetInvalidPathChars()) >= 0;
            }
            catch (Exception)
            {
                return true;
            }
        }

        /// <summary>
        /// 判断文件名字符串是否包含无效字符。
        /// </summary>
        /// <param name="fileName">要检查的文件名。</param>
        /// <returns>
        /// 如果文件名包含无效字符则返回true，否则返回false。
        /// </returns>
        public static bool HasInvalidFileNameChars(this string? fileName)
        {
            if (string.IsNullOrEmpty(fileName))
                return false;

            try
            {
                return fileName!.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0;
            }
            catch (Exception)
            {
                return true;
            }
        }
        #endregion
    }
}
